home *** CD-ROM | disk | FTP | other *** search
/ Network Support Library / RoseWare - Network Support Library.iso / apidev / users.arc / USER.C next >
Text File  |  1989-08-08  |  8KB  |  270 lines
  1. #define MSC 400
  2. #include <nit.h>
  3. #include <niterror.h>
  4. #include <malloc.h>
  5.  
  6. #define LINElength 80
  7.  
  8. typedef struct userLIST
  9. {
  10.    char *line;
  11.    char *nextline;
  12. }userLIST;
  13.  
  14. WORD connectionID;
  15. int loggedfg,allfg,usagefg;
  16.  
  17. main(argc,argv)
  18. int argc;
  19. char *argv[];
  20. {
  21.    char objectName[48];
  22.    long objectID=-1;
  23.    int objectType;
  24.    int connectionNumber;
  25.    BYTE loginTime[7];
  26.    userLIST array,*arrayptr;
  27.  
  28.    loggedfg=ParseCommand("/L",argc,argv);
  29.    allfg=ParseCommand("/A",argc,argv);
  30.    usagefg=ParseCommand("/U",argc,argv);
  31.    if(argc>1)
  32.    {
  33.       printf("\nUSER ID         FULL NAME");
  34.       if(usagefg)
  35.          printf("%51s","Used      Free");
  36.       printf("\n-------         ---------");
  37.       if(usagefg)
  38.          printf("%51s","----      ----");
  39.       printf("\nWorking..........\r");
  40.    }
  41.    arrayptr=&array;
  42.    connectionID=GetPreferredConnectionID();
  43.    if(allfg)
  44.    {          /* list all users in user bindery */
  45.       strcpy(objectName,"****************************************");
  46.       while(name(arrayptr,objectName,&objectID)==SUCCESSFUL)
  47.       {
  48.          arrayptr->nextline=malloc(sizeof(userLIST));
  49.          arrayptr=(userLIST *) arrayptr->nextline;
  50.       }
  51.    }
  52.    else if(loggedfg)                           /* list logged-in users only */
  53.    {
  54.       for(connectionNumber=1;connectionNumber<=100;connectionNumber++)
  55.          if(GetConnectionInformation(connectionNumber,
  56.                                      objectName,
  57.                                      &objectType,
  58.                                      &objectID,
  59.                                      loginTime)==SUCCESSFUL)
  60.             if(objectType==0x0001)
  61.             {
  62.                objectID=-1;
  63.                if(name(arrayptr,objectName,&objectID)==SUCCESSFUL)
  64.                {
  65.                   arrayptr->nextline=malloc(sizeof(userLIST));
  66.                   arrayptr=(userLIST *) arrayptr->nextline;
  67.                }
  68.             }
  69.    }
  70.    else if(argc>1)                             /* list a specific user only */
  71.    {
  72.       strcpy(objectName,argv[1]);
  73.       if(name(arrayptr,argv[1],&objectID)==SUCCESSFUL)
  74.       {
  75.          arrayptr->nextline=malloc(sizeof(userLIST));
  76.          arrayptr=(userLIST *) arrayptr->nextline;
  77.       }
  78.    }
  79.    else
  80.    {
  81.       printf("\n\n╒════════════════════════╕\n");
  82.       printf("│User Information Utility│\n");     
  83.       printf("│By A. White     89/08/03│\n");
  84.       printf("╘════════════════════════╛\n\n");
  85.       printf("Usage: user [user name] [/A] [/L] [/U]\n\n");
  86.       printf("Where: /A -list all user accounts\n");
  87.       printf("       /L -list logged-in users\n");
  88.       printf("       /U -display disk usage for users (time consuming)\n\n");
  89.  
  90.       exit(0);
  91.    }
  92.    arrayptr->nextline=(userLIST *) NULL;
  93.    print(&array);
  94. }
  95.  
  96. ParseCommand(search,argc,argv)
  97. char *search;
  98. int argc;
  99. char *argv[];
  100. {
  101.    int count=1,retval=0;
  102.    while(count<argc)
  103.    {
  104.       strupr(argv[count]);
  105.       if(strcmp(search,argv[count])==0)
  106.       {
  107.          retval=1;
  108.          break;
  109.       }
  110.       count++;
  111.    }
  112.    return(retval);
  113. }
  114.  
  115. print(linearray)
  116. userLIST *linearray;
  117. {
  118.    int count=0;
  119.    if(linearray->nextline!=(userLIST *) NULL)
  120.       sort(linearray);
  121.    while(linearray->nextline!=(userLIST *) NULL)
  122.    {
  123.       count++;
  124.       printf("%s\n",linearray->line);
  125.       linearray=(userLIST *) linearray->nextline;
  126.    }
  127.    printf("\n%03d user name(s) printed\n",count);
  128. }
  129.  
  130. sort(linearray)
  131. userLIST *linearray;
  132. {
  133.    char **ptr1,**ptr2,*ptr3;
  134.    userLIST *arrayptr;
  135.    int swapfg=1;
  136.    while(swapfg)
  137.    {
  138.       arrayptr=linearray;
  139.       swapfg=0;
  140.       while(((userLIST *) arrayptr->nextline)->nextline!=(userLIST *) NULL)
  141.       {
  142.          ptr1=&arrayptr->line;
  143.          ptr2=&((userLIST *) arrayptr->nextline)->line;
  144.          if(strncmp(*ptr1,*ptr2,10)>0)
  145.          {
  146.             ptr3=*ptr1;                                     /* swap strings */
  147.             *ptr1=*ptr2;
  148.             *ptr2=ptr3;
  149.             swapfg=1;
  150.          }
  151.          arrayptr=(userLIST *) arrayptr->nextline;
  152.       }
  153.    }
  154. }
  155.  
  156. name(linearray,objectName,objectID)
  157. userLIST *linearray;
  158. long *objectID;
  159. char *objectName;
  160. {
  161.    char temp[80];
  162.    int foundObjectType;
  163.    char foundObjectName[48];
  164.    char objectHasProperties;
  165.    char objectSecurity;
  166.    char objectFlag;
  167.    BYTE identificationValue[128];
  168.    BYTE moreSegments;
  169.    BYTE propertyFlags;
  170.    int retval;
  171.    long kBytesUsed,kBytesNotUsed;
  172.    int restricted;
  173.  
  174.    retval=ScanBinderyObject(objectName,
  175.                             OT_USER,
  176.                             objectID,
  177.                             foundObjectName,
  178.                             &foundObjectType,
  179.                             &objectHasProperties,
  180.                             &objectFlag,
  181.                             &objectSecurity);
  182.    if(retval==SUCCESSFUL)
  183.    {
  184.       if(ReadPropertyValue(foundObjectName,
  185.                            OT_USER,
  186.                            "IDENTIFICATION",
  187.                            1,
  188.                            identificationValue,
  189.                            &moreSegments,
  190.                            &propertyFlags)!=SUCCESSFUL)
  191.          identificationValue[0]='\0';
  192.       linearray->line=malloc(LINElength);
  193.       sprintf(linearray->line,"%-14.14s %-40.40s  ",foundObjectName,identificationValue);
  194.       if(usagefg && GetSpaceUsage(foundObjectName,&kBytesUsed,&kBytesNotUsed,&restricted)==SUCCESSFUL)
  195.       {
  196.          sprintf(temp,"%7ld K ",kBytesUsed);
  197.          strcat(linearray->line,temp);
  198.          if(restricted)
  199.             sprintf(temp,"%7ld K",kBytesNotUsed);
  200.          else
  201.             strcpy(temp,"     all");
  202.          strcat(linearray->line,temp);
  203.       }
  204.    }
  205.    return(retval);
  206. }
  207.  
  208. GetSpaceUsage(objectName,kBytesUsed,kBytesNotUsed,restricted)
  209. char *objectName;
  210. long *kBytesUsed;
  211. long *kBytesNotUsed;
  212. int *restricted;
  213. {
  214.    int retval;
  215.    long objectID;
  216.    long systemElapsedTime;
  217.    long unusedDiskBlocks;
  218.    char volumeName[16];
  219.    int volumeNumber;
  220.    WORD usedDirectories;
  221.    WORD usedBlocks;
  222.    WORD usedFiles;
  223.  
  224.    if((retval=GetBinderyObjectID(objectName,OT_USER,&objectID))==SUCCESSFUL)
  225.    {
  226.       if((retval=GetBinderyObjectDiskSpaceLeft(connectionID,
  227.                                                objectID,
  228.                                                &systemElapsedTime,
  229.                                                &unusedDiskBlocks,
  230.                                                restricted))==SUCCESSFUL)
  231.       {
  232.          if((unusedDiskBlocks&0x7fff0000)==0x7fff0000)
  233.          {
  234.             unusedDiskBlocks=0;
  235.             *restricted=0;
  236.          }
  237.          else
  238.             *restricted=1;
  239.          *kBytesNotUsed=(long) (((double) unusedDiskBlocks)*4096.0/1000.0);
  240.          *kBytesUsed=0L;
  241.          volumeNumber=0;
  242.          while(GetDiskUtilization(objectID,
  243.                                   volumeNumber++,
  244.                                   &usedDirectories,
  245.                                   &usedFiles,
  246.                                   &usedBlocks)==SUCCESSFUL)
  247.                 *kBytesUsed+=usedBlocks;
  248.          *kBytesUsed=(long) (((double) *kBytesUsed)*4096.0/1000.0);
  249.       }
  250.    }
  251.    return(retval);
  252. }
  253.  
  254. dump_segment(dump,bytes)
  255. unsigned char *dump;
  256. int bytes;
  257. {
  258.    int count=0,x;
  259.    while(count<bytes)
  260.    {
  261.       for(x=0;x<16 && count<bytes;x++)
  262.       {
  263.          printf("%02X ",*(dump+count));
  264.          count++;
  265.       }
  266.       printf("\n");
  267.    }
  268.    while(getch()!=' ');
  269. }
  270.